{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Paddle2.0-通过LSGAN让我们看看AI预测的外星人长什么样子\n",
    "\n",
    "**先看看生成效果：**\n",
    "\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/438b037522e34dfeb968ee7fe74fb8fedda60ebb35e642dabe5d29d35a5298ee)\n",
    "\n",
    " - 本项目将通过爬取外星人矢量图，训练一个生成对抗网络（GAN）来产生新的外星人。为了节省时间，请尽量选择GPU进行训练。\n",
    " - 本项目的综合应用请见项目：**星际终端**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2 参数设置及数据集准备\n",
    "\n",
    "### 2.1 爬取外星人图片\n",
    "\n",
    " - 从百度爬取关键词为“外星人 矢量”的图片。直接用“外星人”为关键词的图片感觉风格太乱了，不好训练。\n",
    " \n",
    "  - 爬虫代码源自最早的项目，可以爬取任意数量，任意关键词图片，训练利器：[Paddle2.0+ imgaug数据增广,新年“集福”示例,年年都有无尽的福](http://https://aistudio.baidu.com/aistudio/projectdetail/1537167?shared=1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import requests\r\n",
    "import re\r\n",
    "import os\r\n",
    "import time\r\n",
    "\r\n",
    "##\r\n",
    "def client():\r\n",
    "    global search_words\r\n",
    "    global pages\r\n",
    "    global end_pages\r\n",
    "    global start_pages\r\n",
    "    search_words = '外星人 矢量'\r\n",
    "    start_pages = 1 ##看我们要下多少页的数据\r\n",
    "    end_pages = 60\r\n",
    "\r\n",
    "        \r\n",
    "#图片爬取函数\r\n",
    "def Pictures_Crawling(indexName=True):\r\n",
    "    index=100000\r\n",
    "    !mkdir pic/\r\n",
    "    for page in range(start_pages,end_pages):\r\n",
    "        url = 'https://image.baidu.com/search/flip?tn=baiduimage&ie=utf-8&word={}&pn={}'.format(search_words, page)\r\n",
    "        #url = 'https://image.baidu.com/search/index?tn=baiduimage&ipn=r&ct=201326592&cl=2&lm=-1&st=-1&fm=result&fr=&sf=1&fmq=1600582955784_R&pv=&ic=0&nc=1&z=&hd=&latest=&copyright=&se=1&showtab=0&fb=0&width=&height=&face=0&istype=2&ie=utf-8&sid=&word=%E9%81%93%E8%B7%AF%E7%A6%81%E6%AD%A2%E8%B7%AF%E6%A0%87'\r\n",
    "        #伪装浏览器请求头\r\n",
    "        headers={\r\n",
    "            'user-agent': 'Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, like Gecko) Chrome / 84.0 .4147.89Safari / 537.36'\r\n",
    "                }\r\n",
    "        \r\n",
    "        #获取网站源码\r\n",
    "        html = requests.get(url,headers=headers)\r\n",
    "        #获取真实的url\r\n",
    "        urls_real = re.findall('\"thumbURL\":\"(.*?)\",', html.text)\r\n",
    "        print('图片url数量',len(urls_real))\r\n",
    "        #print(urls_real)\r\n",
    "        #筛选资源url，并返回元组\r\n",
    "        #urls = re.findall(r'<img alt=\"\" src=\"(http://.*?.jpg)\" ',html.text)\r\n",
    "        #资源存放文件夹路径\r\n",
    "        root = 'pic/'\r\n",
    "        #print(urls_real)\r\n",
    "        for i in urls_real :\r\n",
    "            subname=i.split('/')[-1]#资源存放名称 eg:'u=4117662774,1210746205&fm=193'\r\n",
    "            if indexName:\r\n",
    "                filename=str(index)+'.png'\r\n",
    "                index+=1\r\n",
    "            else:\r\n",
    "                try:\r\n",
    "                    check=re.findall(r\"=(.+?)&\",subname)\r\n",
    "                    if len(check)==0:\r\n",
    "                        filename=subname\r\n",
    "                    else:\r\n",
    "                        filename=re.findall(r\"=(.+?)&\",subname)[0].replace(',','')+'.png'\r\n",
    "                except Exception as e:\r\n",
    "                    \r\n",
    "                    print(e)\r\n",
    "                    print (subname)\r\n",
    "                    filename=str(time.time())+'.png'\r\n",
    "            path = root + filename #资源存放点+资源存放名称\r\n",
    "            #print(path)\r\n",
    "            #i='https:\\\\/\\\\/ns-strategy.cdn.bcebos.com\\\\/ns-strategy\\\\/upload\\\\/fc_big_pic\\\\/part-00094-2012.jpg'\r\n",
    "            if '\\\\/' in i:\r\n",
    "                print('ii',i)\r\n",
    "                i=i.replace('\\\\','')\r\n",
    "                print('ii',i)\r\n",
    "            #print(i)\r\n",
    "                \r\n",
    "            image_data = requests.get(i,headers=headers)\r\n",
    "            with open(path, 'wb')as f:  #将图片以二进制写入\r\n",
    "                f.write(image_data.content)\r\n",
    "            #print('save ',path,i)\r\n",
    "    print('total index',index)       \r\n",
    "runpic=False\r\n",
    "#没有图片文件夹就取爬图片\r\n",
    "if not os.path.exists('pic') or runpic:\r\n",
    "    !mkdir pic/\r\n",
    "    client()\r\n",
    "    Pictures_Crawling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2 定义Config参数\n",
    "\n",
    "定义训练参数，并写入到txt中，以备后续翻查。\n",
    "\n",
    "\n",
    "**设置的超参数为：**\n",
    "\n",
    " * 学习率：0.0001\n",
    " * 输入图片长和宽：128\n",
    " * Epoch: 1000\n",
    " * Mini-Batch：32\n",
    " * 输入Tensor长度：100\n",
    " * Adam：Beta1：0.5，Beta2：0.999  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'img_dim': 128, 'lr': 5e-05, 'epoch': 10000, 'output': 'Output/', 'batch_size': 32, 'G_DIMENSION': 100, 'beta1': 0.5, 'beta2': 0.999, 'output_path': 'Output'}\n"
     ]
    }
   ],
   "source": [
    "import json\r\n",
    "import os\r\n",
    "configPath='configs/'\r\n",
    "if not os.path.exists(configPath):\r\n",
    "    !mkdir configs/\r\n",
    "path=configPath+'config0720.txt'\r\n",
    "##\r\n",
    "dictObj={\r\n",
    "    'img_dim':128,\r\n",
    "    'lr': 0.0001,\r\n",
    "    'epoch':  1000,\r\n",
    "    'output':\"Output/\",\r\n",
    "    'batch_size': 32,\r\n",
    "    'G_DIMENSION': 100,\r\n",
    "    'beta1':0.5,\r\n",
    "    'beta2':0.999,\r\n",
    "    'output_path': 'Output'\r\n",
    "}\r\n",
    "##\r\n",
    "jsObj = json.dumps(dictObj, indent=4)  # indent参数是换行和缩进\r\n",
    "with open(path,'w') as f:\r\n",
    "    f.write(jsObj) \r\n",
    "##\r\n",
    "with open(path) as f:\r\n",
    "    config = json.load(f)\r\n",
    "    print(config)\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.3 数据集预处理\n",
    "多线程处理，以裁切坐标(0,0)和(128,128)，将输入网络的图片裁切到128*128.用多线程处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.2\n",
      "已处理图片数量：482\n",
      "已处理图片数量：482\n",
      "已处理图片数量：482\n",
      "已处理图片数量：481\n",
      "已处理图片数量：482\n",
      "已处理图片数量：482\n",
      "已处理图片数量：482\n",
      "已处理图片数量：482\n"
     ]
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import os.path\n",
    "import os\n",
    "import threading\n",
    "import paddle\n",
    "from PIL import ImageFile\n",
    "print(paddle.__version__)\n",
    "ImageFile.LOAD_TRUNCATED_IMAGES = True\n",
    "\n",
    "'''多线程将图片缩放后再裁切到128*128分辨率'''\n",
    "#裁切图片宽度\n",
    "# w = 512\n",
    "#裁切图片高度\n",
    "# h = 512\n",
    "ww = config['img_dim']\n",
    "hh =  config['img_dim']\n",
    "#裁切点横坐标(以图片左上角为原点)\n",
    "x = 0\n",
    "#裁切点纵坐标\n",
    "y = 0\n",
    "\n",
    "def cutArray(l, num):\n",
    "  avg = len(l) / float(num)\n",
    "  o = []\n",
    "  last = 0.0\n",
    "\n",
    "  while last < len(l):\n",
    "    o.append(l[int(last):int(last + avg)])\n",
    "    last += avg\n",
    "\n",
    "  return o\n",
    "  \n",
    "def convertjpg(jpgfile,outdir,width=ww,height=hh):\n",
    "    img=Image.open(jpgfile)\n",
    "    (l,h) = img.size\n",
    "    rate = min(l,h) / width\n",
    "    try:\n",
    "        img = img.resize((int(l // rate),int(h // rate)),Image.BILINEAR)\n",
    "        img = img.crop((x,y,width+x,height+y))\n",
    "        img.save(os.path.join(outdir,os.path.basename(jpgfile)))\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "\n",
    "class thread(threading.Thread):\n",
    "    def __init__(self, threadID, inpath, outpath, files):\n",
    "        threading.Thread.__init__(self)\n",
    "        self.threadID = threadID\n",
    "        self.inpath = inpath\n",
    "        self.outpath = outpath\n",
    "        self.files = files\n",
    "    def run(self):\n",
    "        count = 0\n",
    "        try:\n",
    "            for file in self.files:\n",
    "                convertjpg(self.inpath + file,self.outpath)\n",
    "                count = count + 1\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "        print('已处理图片数量：' +  str(count))\n",
    "            \n",
    "if __name__ == '__main__':\n",
    "    inpath = '/home/aistudio/pic/'\n",
    "    outpath = '/home/aistudio/data/imgs/'\n",
    "    \n",
    "    if not os.path.exists(outpath):\n",
    "        os.mkdir(outpath)\n",
    "        files =  os.listdir(inpath)\n",
    "        files = cutArray(files,8)\n",
    "        T1 = thread(1, inpath, outpath, files[0])\n",
    "        T2 = thread(2, inpath, outpath, files[1])\n",
    "        T3 = thread(3, inpath, outpath, files[2])\n",
    "        T4 = thread(4, inpath, outpath, files[3])\n",
    "        T5 = thread(5, inpath, outpath, files[4])\n",
    "        T6 = thread(6, inpath, outpath, files[5])\n",
    "        T7 = thread(7, inpath, outpath, files[6])\n",
    "        T8 = thread(8, inpath, outpath, files[7])\n",
    "        \n",
    "        T1.start()\n",
    "        T2.start()\n",
    "        T3.start()\n",
    "        T4.start()\n",
    "        T5.start()\n",
    "        T6.start()\n",
    "        T7.start()\n",
    "        T8.start()\n",
    "        \n",
    "        T1.join()\n",
    "        T2.join()\n",
    "        T3.join()\n",
    "        T4.join()\n",
    "        T5.join()\n",
    "        T6.join()\n",
    "        T7.join()\n",
    "        T8.join()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 3 模型组网\n",
    "\n",
    "### 3.1 定义数据预处理工具-Paddle.io.Dataset\n",
    "具体参考[Paddle.io.Dataset教程](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/io/Dataset_cn.html#dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/__init__.py:107: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import MutableMapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/rcsetup.py:20: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Iterable, Mapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/colors.py:53: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Sized\n",
      "2021-07-28 10:44:13,084 - INFO - font search path ['/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/ttf', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/afm', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/pdfcorefonts']\n",
      "2021-07-28 10:44:13,514 - INFO - generated new fontManager\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "# from skimage import io,color,transform\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import time\n",
    "import paddle\n",
    "from paddle.io import Dataset\n",
    "import six\n",
    "from PIL import Image \n",
    "import paddle.fluid as fluid\n",
    "from paddle.static import InputSpec\n",
    "paddle.enable_static()\n",
    "# img_dim = 512\n",
    "img_dim = config['img_dim']\n",
    "\n",
    "\n",
    "'''准备数据，定义Reader()'''\n",
    "PATH = '/home/aistudio/data/imgs/'\n",
    "\n",
    "class DataGenerater(Dataset):\n",
    "    \"\"\"\n",
    "    数据集定义\n",
    "    \"\"\"\n",
    "    def __init__(self,path=PATH):\n",
    "        \"\"\"\n",
    "        构造函数\n",
    "        \"\"\"\n",
    "        super(DataGenerater, self).__init__()\n",
    "        self.dir = path\n",
    "        self.datalist = os.listdir(PATH)\n",
    "        self.image_size = (img_dim,img_dim)\n",
    "    \n",
    "    # 每次迭代时返回数据和对应的标签\n",
    "    def __getitem__(self, idx):\n",
    "        return self._load_img(self.dir + self.datalist[idx])\n",
    "\n",
    "    # 返回整个数据集的总数\n",
    "    def __len__(self):\n",
    "        return len(self.datalist)\n",
    "    \n",
    "    def _load_img(self, path):\n",
    "        \"\"\"\n",
    "        统一的图像处理接口封装，用于规整图像大小和通道\n",
    "        \"\"\"\n",
    "        try:\n",
    "            img = cv2.imread(path)[:,:,:3]\n",
    "            img = cv2.resize(img,self.image_size)\n",
    "            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "            #mg = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
    "            # img_norm = np.zeros(img.shape)\n",
    "            # img = cv2.normalize(img, dst=img_norm, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX)\n",
    "            img = np.array(img).astype('float32') # 转换成数组类型浮点型32位\n",
    "            img = img.transpose() # 矩阵转置\n",
    "            # print(img)\n",
    "            img = img/255.0\n",
    "        except Exception as e:\n",
    "                print(e)\n",
    "        return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(128, 128, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2349: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  if isinstance(obj, collections.Iterator):\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2366: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  return list(data) if isinstance(data, collections.MappingView) else data\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/numpy/lib/type_check.py:546: DeprecationWarning: np.asscalar(a) is deprecated since NumPy v1.16, use a.item() instead\n",
      "  'a.item() instead', DeprecationWarning, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJIAAACSCAYAAACue5OOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJztXXl4VNXZ/907d2Yyk2Um+w5JSEjCImsAEQRF3EAf236t1LZqfSzVCi710SpVP63a+ilUrQsq6qNS1MdKARUipBggEEyMBAgxsoTs28wkM5l9u/N+f8R7vpksMJMMBfrN73nmAYY7973n3N855z3vdjgiQgQRjBX8+X6ACP4zECFSBGFBhEgRhAURIkUQFkSIFEFYECFSBGFBhEgRhAURIkUQFkSIFEFYECFSBGGBEMrFHMdF/Cn/z0BEXDDXRWakCMKCCJEiCAsiRIogLIgQKYKwIEKkCMKCCJEiCAsiRIogLIgQKYKwIEKkCMKCCJEiCAsiRIogLIgQKYKwIEKkCMKCCJEiCAsiRDoDOI4DxwUVRfH/HiHFI/07MNKLk1LLpf/nOA6D081Hk37uL08QBCQlJSE/Px/jxo2DSqWCKIo4cOAAOjo64HA4AmSEIi8YQg5uY7DXj1a+/0AhIna/UJ8DuACJJEFqpFwuR1paGsaNGweNRgOPxwO9Xo+Wlhb09/ezDvDviGDvL/0pCAImTpyIm266Cddeey0mTJiAuLg48PzAhN3S0oKqqip8+umn2LdvHywWC4DQiesvUy6XIyMjA9nZ2eB5Hnq9Hp2dnbBYLFCr1UhLS0NaWho4jkNPTw/a2toCiByKbJ7nWX8qlUqkpaUhPz8fWVlZiI+Ph0wmg9lsRnt7OxobG9He3g6bzQafzxd820Ls/HMeISk1WKVSoaSkBDfffDMWLlyI9PR0KJVKiKIIm82GxsZG7Ny5E1u3bsWJEyfg9XpDa/gPcuLj4/HLX/4Sd911F/Ly8iCTydhsJxFJIqnZbMYXX3yBv/71r6ivr4fH4wlJHgAolUpMnz4dt912GxYvXoyUlBTwPA+z2Yzm5ma0tbUhNTUVeXl5iI+PBxHBaDSiqqoKGzduREVFBSNUsO+O4zjExcVhwYIFWLFiBUpKSpCWlgaVSsXaK4oiXC4XDAYDjhw5gs2bN+PLL7+ETqcLfnoM9gOAztWH4zjiOI5kMhllZmbSs88+S+3t7SSKIvl8PpLg8/nYx+PxUENDA919990UHx/P7vED4c8oh+d5ys7OpjfeeIOsVuuQe59J5qFDh2j58uUkl8tJJpMRz/NBtSsuLo7uvfdeOn36NHm93iH3Hu7f0neiKFJ3dzc99dRTlJKSQjzPn7G9UhtlMhnl5+fT+vXrqa+vL6A/B8uQIIoiWSwW2rx5MwXNjQuBSFKjU1JS6M033yS73U6iKFIwkDrdbDbTn//8Z9JqtSSTyUaUI5PJSKVS0aOPPkpGo5G8Xm9AJwYrz+v10p49eyg3N3dEIkntUigUtGLFCurs7CSPxxOSvMHwer1kMpnokUceIaVSyQg1nOzs7GzasmULud1uRsZg2yiKonT9xUUktVpNa9asYbNDqPD5fGQwGOiOO+4gQRCGlcPzPPE8T7Nnz6bm5uYhIz9UeS6Xi/70pz+RQqEYsV2CINDEiROpurp6TPL85YqiSM3NzTR//vwhRJLaqFAo6KmnngppUA6W88OzXlxEWrRoETU1NY2poz0eD3399deUlZU1ohyFQkFr165lS8tYIIoiHTt2jAoKCs5IpAcffJAcDseY5Q2W/eqrr5JSqQwgkjQLTps2jRobG8nr9Y6KSH4IihsXhB0pJiYGd955J7KyssZkt+E4DpMnT0ZJScmI16SmpmLJkiVMkR4LfD4fcnNzcdlllw373EQEjUaDa665Bkqlcszy/MHzPBYtWoT09PSA3SDHcZDJZFi+fDmys7PZ9+ca55VIHMeB53lMnToVV1111ZgbzPM8VCoVZs+ezXYjg++Zn5+P8ePHj0kOMEASaTs9d+5cKJVKts32R1ZWFoqLi8csbzj5WVlZmDhxYoBJgIgQGxuLK664AnK5fNhnOhc47zMSz/NYtmwZkpOTxzxL0A9b9vHjx7MOlDoZGCBubm4uoqOjx9y50iDgOA6FhYWIjo4e9rqsrCxoNJoxyRpJfmxsLPLz84e0JT09HQUFBey6fwfOO5G0Wi0WLVo0rKU6FPj/Nioqit3PvyM5jkNqaip4nh+TLH9wHAetVguVSjXEtsNxHJKTk8O+rEngeR5JSUlDyJKZmQmtVntOZI74LP9WaYNARBg3bhxyc3PDMgVL5LHZbCMSRVqCwgm5XA5BENgzSCAi9v25wuD7cxyHxMREKBSKcyp3MM77jDR+/Hg2esaqaEtob2+H1+sd9rpQTf/BwO12Myv34BnJYrFAFMWwypPg8/lgsViGDBqVSvVvdzafd2U7PT09rKPH6/WioaFhWP+bz+dDT09P2InU29sLu90+5HsiQmdn57D/Fw54vV60t7cP+d7pdIZt6Q4W591pGxMTE7RnfLCnerD3GgBMJhMaGhpGvE9bWxtsNhs0Gg1EUQy4r3Q/f/1K+rv/zkgURaZsA8Dp06dht9uHvDyO49De3o6enh4kJCSE2DNnh8lkwqlTp4bINRqNcLvdkMvljMQKhQKCIAT0tf8S79+n0v18Pl/QS/N5J9JIS9Bg+HeAz+eD0+mEQqGAXC5n3xMRjh8/jpaWlhHv09LSAr1ej/b2duzatQsymQwAUFxcjGnTpiEpKWmIDiXpXSdOnMChQ4dw4sQJAMCsWbNw/fXXn9GBq9PpcPjwYRQVFYV9uTl58iSam5sDiC/NghaLBV6vF08++SRMJhMWLlyI4uJiFBUVQavVDrsZkdpqt9tRW1uL8vJyPPHEE0E9y3klEhGhr68PoiiyF3o2WCwWbNmyBV9++SVuu+02XH311awzvF4v9u3bB5PJNOLv9Xo9Tp06hbq6Onz66ae49tprceDAATzzzDOYPn067rvvPlx99dUBBG1sbMQbb7wBh8OBQ4cO4dtvvwURYebMmZgxYwYaGhpGXC6dTic+//xzLF++HHFxcUPaP1pyeTwelJaWwmg0DrlfV1cX2trakJmZiYqKCuTk5GDhwoXo6enB5s2bMWfOHEydOnXIPYkI7e3tWL9+Pf7+979Dp9NdHEQCgKamJlgsFjb1nymwzW63Y926dXjppZfgcDgwffp0LF26lP2mt7cXZWVlZ1Ru7XY7KisrUVRUhFOnTmHt2rXgOA5OpxNfffUVWlpa8O6772L+/PnsxTzyyCM4fvw4Zs+ejdbWVvh8PhAR0tLSoNfrR1xKiQg+nw/79u1DdXU1Fi9eDFEU4XA44PV6oVAooFarA5ZUqS0+n4+1w2azobe3FxzHISEhATExMTh58iQ+++yzYXWh/v5+1NbWIicnB0qlEkajET6fD7NmzUJOTg62b98OuVyOSZMmMXmiKKK7uxuVlZXo7++HTqcLaZNwXonEcRxOnTqFxsZGxMfHs++GAxGhrq4O7733HiwWCzQaDQoLCwNihmpqanDs2LERbVKSHlBWVoZly5Zh8uTJqKqqYroSMKDvvPfeeygpKWGbgLKyMrjdbpw6dYotYbGxsbjxxhuxf/9+6PX6EdsHDMyC77//PjQaDQ4fPoxJkyZBJpPhm2++QW5uLkpKShAVFYXY2Fj2G6fTCZPJBKvVioqKCjZD5OXl4bbbbkNtbS1Onjw5ZJfIcRw8Hg/Ky8vx05/+FAUFBfj000/xi1/8AlOmTMH06dNRXFyM3bt3Iysri+2YPR4PvvrqK+Tn58NsNrPBEjSCdcrROXDachxHcrmcHn/8cXK5XCxWZqR4nHfffZeio6NJEAS6/vrrqaOjg11ns9lo5cqVJAjCGeOReJ6nmJgYevvtt+nvf/87TZgwISAMhOd5Kikpoe7ubhZKIZPJ2IfjOIqJiaHf/OY3VF1dTXPmzAkq/ik3N5eef/55mjx5Mj3//PNUU1NDS5YsofHjx9PLL79MR44cof7+fiIicjqdVFdXR0ePHqW2tjbavHkzZWZmkkwmI7VaTU8//TTNmzePOWgl+dK/eZ6n3NxcOnToEH3yySeUnJxMMpmMBEEglUpFBQUFNHXqVNq1axdz6DY0NNC1115LN9xwA2m1WnbfYLlx3nUkj8eDjz76CDfeeCMmTZqEvXv3orGxEcnJyZg1axbGjRvHdg5qtRqFhYWYOXMmVq9ejZSUFNaQU6dOYc+ePWfd2vt8PlitVrz99tt45plnsGbNGuzYsQO1tbVMt/KXSURITk6Gw+GASqXChAkTcPXVV2PBggXYvn076urqztpGAOjp6YFMJkNycjJeeuklbNq0CQ0NDRBFEevWrYNWq4Ver8eCBQtw+PBhdHR0YMeOHSgqKoJOp0NfXx8AYPLkyRg3bhyampqGmDf8/93e3o5t27Zh9erVWL16NV599VX09fXB4/GgsbERHMehoqICixYtgiAIOHz4MCoqKuByudiSHhMTE/S7PO86EgA0NzfjhRdewLPPPott27bhvffeg0wmw8SJE7F69Wr8/Oc/h0KhwLXXXovLLrsMCQkJUCqVbCoXRRFffPHFGXdrg1FbW4t3330Xq1evxty5c2Gz2WC32yEIAosPl17M559/DovFAqVSiZiYGMhkMhw4cADvvPMO3G53UO4dp9OJb7/9FitXrsQf/vAH1NXVsefv6urCJ598gltvvRUOhwNOpxO7d+/Gpk2b2O+9Xi+SkpKwatUqNDQ0MGKNBK/Xi48//hg33HAD7r//fpSUlKC0tBRNTU0ABgaLv2uquLgYq1atwqlTp2C325GZmYmlS5cG3Z8XRDyStNw89NBDVF5eTjfddBPl5eXRzJkz6fHHH2eRjNLHP4JPFEVqa2ujOXPmBISfBiMzOjqa7rnnHtLpdOR2u1nsjiiK5PF4Av6UoiLtdjtt2bKF8vPzQ5LHcRxlZGTQl19+SR999BFdeeWVlJWVRenp6VRcXEyrVq2ilpYW8ng8ZDab6Y033qCpU6dSYmIiJSUl0fTp0+n111+nqqoqmjp16lllchxHSqWSbr/9dtLr9SSKIjmdTjKbzWQ2m8nlcrH+FEWRvF4vuVwuslqt1N/fTw6HQ4rZCo4bFwKRpJeh1WrpwQcfpLq6Oqqrq6Ompiay2Wzk8/nIZrOR0Wik6upqcjgc5PF4yOv1ksfjoQ0bNpBarQ5ZJs/zFBcXR8888wxZrdYAIh07doxaW1vp66+/Zh3tdrtp//79dMkll4wYhXkmeTKZjJYtW0bHjx+nzs5Oqqmpof3791NZWRnV19dTf38/2Ww2MpvN1NnZSZ9++il9/vnnVFZWRsePH6f29na64447SKVSjRhOPHiwaLVaeuGFF8hmsw0JK7ZardTT00O9vb0snltqq0Ssi5JIPM+TWq2m5cuXU3l5OdlsNta47777jnQ6HX377bdUX19PTqeTvF4vtbS00KWXXhpUxw5HJJ7nKTk5mTZs2EB2u528Xi85nU767rvv6OTJk1RXV0cej4fcbjc1NDTQ5ZdfzhTv0chTKpW0dOlS2rZtGxkMBvJ4PNTT00Nms5n0ej1ZLBbq7e0ll8tFBoOBXC4Xmc1mKi8vp5/97GdssxHsLMhxHKWlpdHGjRvJ6XQy5drn81FfXx+1tbVRT08PdXZ2DpmR9+zZc3ESyf/lZmRk0G9/+1vau3cvmc1mcjqddODAAXrttdfo0KFD5Ha7yW6305/+9CeKiooKqmPPJHP8+PG0detWcrlc5Ha7Sa/XU3d3N/X09JAoitTe3k4333wzCYLAnnG0xBUEgeLj4+nRRx+l/v7+gBnP5XKx5dTr9ZLD4aBXXnmFMjMzSRAEJj+YpU26jud5ysvLoy+++IIlAng8Hvr+++9p586dtH37dqquria73R6QKTN37tyLi0gjfQRBoMzMTLr99ttp9+7d1NraSmazmTweD7lcLtq9ezfl5eWN6sX6f6SXO2fOHKqpqWEvUvr09fXRH/7wB4qOjg7bwOF5npKSkuiNN94gm81GHo+HDAYDtba2Uk9PD7ndbnI6nbR582bKzc09a9rT2eQJgkAzZsygiooKcrvd5PF4qKurixobG6mpqYlaWlqYynDixAm6/vrrSS6X/2cQSepwhUJBeXl59MQTT1BdXR3p9Xrav38/XXnllayDx0Ik/2XnhhtuoKNHj5LL5WIK9tq1aykpKWlMMoaTx/M8ZWVl0XvvvUd2u50toR6PhzweD+3atYuKiopGPQv6y5PsSAsXLqSqqiq2jEk6k7ScNTU10S233EJRUVEkk8n+c4jkv/woFArKzc2lOXPmUHZ2NlN4g905na2jZTIZKRQKmjp1Kq1Zs4Y2btxIr776KsXFxY1ZxnDtkhIY8/LyqLS0lOW8iaJIR44codmzZzMjaDjaKBmA58+fz2Ym/zy9Y8eO0Y9//GNSKBQhGyQvaCKdzw/P8ySXy0PenY1GjiAING3aNHr55Zfp888/pw0bNtAVV1wRtFIdqjyZTEZFRUW0YcMG6uzsJIPBQP/85z9p7ty5pFAoAmQGy40LLvf/fMPfuDg41ulcQPIVchwHhUIBhUIBj8fDgtM4jgtrIJ7UJp7nodVqMWXKFKjVatTW1jKfob+fjYI8HSlCpDMgGIt1uOQM93cJ54JIg4P2/OX6kShoIp33mO0LDVIH+88U5xp+qsOQF+ofWhIu+N9TkusfzDc4pCUYXBC+tgsNMpkMCoWC+fGcTue/Ta5Go0F8fDwEQYDD4YDBYDgnMd8KhQJarRaCIMBms0GpVCIvLw8JCQno6urCiRMnYLPZgr7fBUUkaSYQBAFqtRo8z8PhcMDlcrHp/VwsNZJctVqNGTNmYMGCBSgoKEBMTAzMZjPeeecdHD16lKU5jXXJGxzmyvM8srOzcdNNN+G6665DTk4OK35VU1ODzZs3o7KyElarNeA+wT6D/zLG8zzy8/NZfSa1Wo3e3l6oVCrk5eVBrVbDZDKhvLwcL730UvCNuhB2bdL2W6PR0HXXXUcvv/wy7d69m/bt20cff/wx3XfffVRUVERyuTwoq26oH57nqbCwkNavX0/t7e0B22Kfz0ctLS300ksvUW5uboANaKxt5n4oanH11VfTnj17WOUQf9ler5c6Oztp7dq1lJ6ezmSHIt/f1LBgwQLau3cvORyOEYtLiKJIbrebKioqLq7tv0wmo8LCQnrzzTdJp9MN8fk4nU46evQo3XXXXaTVasNOpLy8PNqxYwfz30kvU/rT4/GQw+GgzZs3U3Z29piszINf7tKlS6mhoYE5VIf7eL1estls9NZbb7EgtVDl8zxPRUVFVFFRwRzeI1V+kfrd7XZfHESSOrOwsJBKS0vJ6XQOW7lM6kyj0RhQTCscBjqlUkkvvvjikAhN6Rn8n8XtdtOTTz7JClyNRbZMJqNx48bRvn37zliVzv/fNpuNVq1axSrFhSJPoVDQc889F9DOkSDJu2gKbUn+psGe6ZFGieT3WrlyJVvmxkqkqVOnsrpMwRTCqquro4KCgjHLFgSBfv3rX5Pdbj+jvMGorKykrKyskJe2rKwsqq2tHU39qaC4cd63/zfeeCNuuOEGCIIQsA0eCRqNBitXrkR6evqYFF76QdmdN28eMjIy2Pdn2/Lm5uZi1qxZo5YrQS6XY8mSJVCpVCH9rrCwEJMmTQrpN0QDNRbGjRt3zswZ551Id9xxB2JjY8Hz/BkLSUg7K+6HMjIzZswYc60AmUyGSZMmsRy2YO6nUqlQXFw85kIUMTExyM3NDfl30dHRyM3NDWkQcT9UTFEqlefMwHre05GmTp0a1Evxt8gqlUrk5uaOeXQJghByAQuOGyipPBYiERFkMlnIsxEwYGuS6jsFSwoiCki5Ohc4rzOSlCAYKnieD0vNISJiKeNny+MiImbL8nq9Y34pXq93VIZOn88Hh8MR8u/0ej0sFss5W9rO64zkP7JCaaDP52NV/8cCKbu0ra0N27Ztw6xZs5Cbm4vExETIZDJWkOvkyZOorKxEb28vfvGLX6Czs3NM/i/uh8xeqVKJ1WpFVFRUQNatdB0Rwe12M2OoTCZDZ2dnyEtbS0sLGhoakJqaOmx/+/vd/Nvmn7p+JpxXIknHNIQ6Sux2OxobG8dsXfb5fDhy5AiamprwxRdf4NJLL0VbWxsMBgMKCwvZknD//fdj7969SE5OxsKFC3Hs2LExk9jlcuHIkSPQ6/U4ffo0DAYDioqK8Ktf/QopKSkABrJfq6qqcODAAezcuRNRUVF44IEHWF5aKM9gNpuxefNmREVF4eDBg8jJyWHKvlR3wWq14ptvvoFWq4XD4YDFYsGyZcuCExDs9o7OwfY/Nzf3jDYUu91Oe/fupU8++STA6vvRRx+RWq0edZy2fyxzVFQU/e1vf6MXXniBMjIyKCoqitLS0uidd94hl8tFL774IqnVasrKyqLXX3+d/vKXv7DAr9G2W5KdmppKb775Jl122WWkVqtJLpfThAkTqL6+ntxuN61Zs4YUCgUplUpKSEigP/7xj3TbbbeFHKckydNqtfTEE0/QtGnTKD09naZMmUIPPPAANTc3065du2jatGkkl8spLi6OVqxYQffee2/Q2//zOiP19/cP+U4aaaIo4rPPPsOjjz6KtLQ0XHHFFYiKioLT6URpaemoHan+9SOJCC6XCx9++CE2bNiAKVOm4OjRo+B5HjNnzgTHcZg/fz6eeuopzJo1CxqNBnfccUfoefEjoLe3F6Wlpfj973+P6upq1NfXIzU1lemNRUVFuOqqq6DRaLBw4ULI5XK88847IS+rRAM+NovFgrq6Ojz22GMoLy+H2+3GkiVLkJKSAplMhjvuuAMGgwHZ2dlISkrCH//4x9CEnK8ZSRCEAGu2/6zU19dHy5YtI6VSSXfddRdL2Dty5Ajl5OSMKvRUEAS65pprWL6/v79r1apVpNfrWU6XzWYji8XCUpS6urrotttuI6VSyWKoR9tu/1kxJiaG7rnnHuro6CCz2UxWq5WcTif7mM1mMplMVFZWRtOnTx9VjLp/qK5arabbb7+dvv32W+rv7ye73U5Op5OsVisZjUYyGo30/vvv08yZM0kQhKBnpPPuIqmpqaHW1lbasmUL7dmzh71MnU5HN998M91yyy1UV1fHEvbWrl1Lcrl8VPLkcjk9++yztGLFiiHV8jUaDT377LMsS6W7u5uOHz9OPT09ZDKZ6LHHHqOYmJiwxm5LsuPi4uipp56i/v5+8ng81NnZSc3NzdTf309er5dqa2tp4cKFJJfLwxK7LZfLaeHChXTs2DFyu91swFitVnrllVcoMTGRkfWiIBLP8/SrX/2Ktm/fTsXFxZSRkUF33303dXd3k8vlora2Nurr62OOVLvdTrfffvuoO5LjOPr5z39Ov/3tb4c9diElJYVee+01slgs1NPTQ6dPnyadTkfr1q2jxMTEkJMig30mmUxGKSkp9Pbbb5PD4SCTyUS9vb3kcDiotbWVfvKTn4zZvze4rXK5nH7yk59QU1MTuVwucjgc9P777zP3i5QIcdEQKTo6mu69917atGkT/fnPf6Z//OMf1N/fTy6Xi/R6PTkcDuZAdLlctGrVqjER6ZJLLqGHHnoogBT+oSFpaWn01ltvkcViIa/XS2azmdLS0lhy4rkgkrTMTZgwgUpLS8lms5Hb7SadTkerV68mtVo9quzekfpckqdSqejOO++kgwcP0sGDB6mgoIDkcjlpNBqaO3cuPfHEExcHkaRPVFQUrVixgg4cOEBWq5VcLhe1t7dTfX09nT59mlwuF9lsNrLZbPTqq6+yzNpQR6hCoaDly5fT5s2bKS0tbUh2rzQSk5KS6LnnniOTyUQvvPBCWHLnzvZiJdkTJ06k9evXU0dHB913332k1WpJEIQxRzuMRGKlUkm33norbd++nRYvXkwPPPAA7dixg5qbm+no0aMXF5GklJy8vDx64IEH6MCBA9TZ2Ul79uyh5uZmstvttHXrVuro6KD29nZavXo1JSUlhTxDFBQUUHV1NZnNZnrooYcCCCm9yJiYGJo3bx699957ZLPZ6OOPP6bo6OiwxCCN1HbpDLnp06fT448/TocPHya73U4HDx6k3//+9zRp0qSwLW3+H5lMRvPmzaOKigqyWq3U1dVFRqORDh48SA8++CAVFhZeXETynxmkrNpHHnmEjh49SkajkXbu3El33nkn9fb2srikTZs2UUlJSUjT/ZIlS8hgMJDX66Xdu3ez7FlJTykoKKC1a9eyWVAURXI4HLRu3TqaPHnyOVnaJP3o4YcfpoaGBhZOI+X+22w2qq2tpbvvvpvi4uLCKrugoIDKysrI7XaTKIpkNpvp+eefp7y8PGYru6iINNxHLpdTUVERK4/3u9/9jpkKpIILdXV19LOf/WzImWUjfSZOnEifffYZ9fX10SeffEKxsbFsNho3bhxt27ZNigokov8LbHO5XHTw4EFasGBBWJcY7odSPuvWrSOLxTJirJBkDpFOjRzNsj540CqVSvrrX/8aQNwDBw5QRkZGwPUXPZGA/9Mf5HI5/e1vfwsYqUajkb755hs6efIk3XzzzSOe4jh49CclJdGTTz5J69evZ3WGBEGgVatWkdVqHfZlSsQtKyujjIyMsMSNSy/0+uuvZyaPkYgk1YFqaWmhkpKSMcmX5Obn59Px48cDimW89dZbFBUVNSoinfd4pDNBekiFQjHkjDWHw4GXX34Ze/fuxWOPPYZLL730rLW6iQbqen/55ZfIyspCUlISgIGDbhYuXAgAw5YEJhpwnM6ZMwezZ88ecyyS5JiVyWS46qqrEBsbi4aGBnYM/GD09fXhxIkTSElJwWWXXTamA4B+mBAwadKkgEMDgYG6k6M9N+WCJpIEKW7nyJEjAAbcHMnJyZgyZQr+8pe/4PTp01izZg3Gjx/PvPbDQSJmc3MzlEolLrnkEhAR0tPTMWXKFJSXl6O3t3fI73p7e7F582YQ0RlPpwwW0stLSEjA3LlzceLECbz44ovDuowAoLu7G+vWrYNOp8PChQuhVqsZIUYDnucxefLkgKMwRFEc0zktFwUY6uw4AAARW0lEQVSR1Go1bDYbtm7dCo/HMzCV8jxKSkpgtVrx5JNPQqvV4tZbb2WJjcNBIpLZbIbBYGD+q7lz50KlUuGLL74Y1ofncrnwwQcf4F//+hcWLVqExMTEMcX1SM8/f/58TJgwAevXr8fBgwdH9B/abDb861//wvvvv49Zs2bhkksuGbV8juOgUqmQlpYWUNBUFEUYDIZRE/SiIJIgCJDL5WhsbGTZnxzHYcKECcjIyMCxY8ewbt06LF68GNnZ2SOOKmlJcbvdaGxsxNy5c5GSkoKrr74aJ0+eRHV1NaxW65DOtNvtaGlpwYYNG5CZmYk5c+aMuU1qtRorVqxAQ0MDtm7dCr1eD4PBMOQ6IkJHRweMRiM++OAD9Pf347/+67/GFNgnxST5nwPjcDig0+lGfc+LgkjAQDSlwWCAyWRiOkJiYiImTJgAURRRVlaGxsZGZGdnn3Vp83q9qKurQ0ZGBkpKSjBr1ixUVlaio6MD3d3dzLsvEUqn08FkMqG6uhonT57EsmXLEBUVNab2FBQUoKSkBNu2bYNer2eH5kgypT99Ph9OnDgBp9OJ1tZW7N69G4sXL0ZmZuao5HIch5ycHHR1dQUErXk8njMemHg2XBREcrvd4Hkebrc7YDpWqVTsPA2bzYampiZWcPxs+O677+DxeHDNNdcgLi4OlZWVMJvNOH78eECEIgCcOHECVqsVZrMZFRUVmD17NpKTk0fdHp7nMWvWLKhUKtTU1MDn88Hj8eDw4cNslpBkO51O1NXVQRRFeDweHDx4EKmpqZg8efKoZHMch6ysLHR3dwfEjPt8vjFFfV4URLJYLHC5XIiJiUFXVxf7XlIaJb3I6/UGvc63tbXh+++/x5IlS9DZ2Yn6+no2Uw0OlK+rq2O6mRQzVFxcPOpKIbGxsbjqqqtgtVrR3d0NImIzj9vtDpiVLBYLmpqamCzpUJ2lS5eyovWhICoqChqNBv39/QFE4nk+6BOqhsMFTSRpeXE6nbBYLEhPT0dHRwf7f47jkJeXB41Gw/SokbbQgyEpsBqNBmVlZdDr9fD5fNDr9UOC+/v6+tizdHd3Qy6XY+nSpaM++bKwsBCXXnop2tvbGfGl5dS/WIZEEv9Auu7ubvT29mLJkiUsTy0Uc4RWq2XHuPvrWXK5fEzpShdUNZKR4PP54PV6IQgC2tra4PP5WOelpKQgMTERLpcLCoUCbrc7qHuKoogtW7bAZrOhsrKS2U+kOHL/lyMdxc5xHDo7O6HX6zFv3jx2fgiAkF5AQUEBNBoNampqGPE5buixrEQEtVodsIwaDAYcOXIEy5YtQ3Z2dsix64mJiUxV8G+jTCYbk953Qc9IAFiZG5VKhb6+PnR2dgbsNhISEjB+/HhER0cjJiYmQEk+G/R6PTZt2oTTp0+DaCBDY8KECQEH2hAR8vPz2Xd6vR5VVVWIj49nh76EsrxwPxwWYzabUVpaymYgQRAwbdo0yOXyAIuxSqUKyP1zu90oLS2Fy+UKIHiw0Gq17FwV/zYCA2QarVnhgiaS1HlxcXFISEhAe3s7LBZLgFKoUqmwYMECxMbGIiEhIWirr7SMSMsGx3GIjo7GjBkzAq4hIlxyySWMpG63G7t27YLH44FMJguJuFI8uiAIaGxsxHfffcdsSomJiSgpKRlSSU0QBMyZMwfR0dFsx1lTU4Pu7u6g09wl2cBAyrt0CtTgJTXYY2GHwwVNJGCgsZLFurW1FVFRUUPK1E2fPh3x8fEYN24cy5wNBdILTk1NRUFBAavUJu0A8/PzkZGRwRIHTpw4AbPZzJTTUJYW7oeio83NzbBarUx2RkYGxo0bB6KBhITW1lb2YgsLC5k7BxiwtHd3d4e8FEmp22azmeXQORwOEBHb/o8WFzSRpJli9uzZaGxshMFgQGxsLAAEzCZarRYqlQqZmZlYsmQJ5HL5qHZUmZmZSEhIAMdxOHToEB5++GHU1NRAq9UGFK0wGo2w2WxBJw/6g+d5aDQa6PV6ps9xHIfU1FQ269TX1+Phhx9GW1sbgIHlSLKmS8mVvb29IZ2nBgwsXWlpaeB5nqkKb7zxBnp7e1ke22hxQRMJGNiuzps3D3v27IEoikhOToZMJkN/f3+Ab6q/vx8ejwf33HMPFixYEJJjUyLI+PHjoVar4Xa7sWnTJmzYsAFbtmxBVFQUEhIS2HVOpxNer5elDYVCWEEQkJaWBo1GE6BYJyQkQKFQgIjw1VdfYffu3Th48CB8Ph+ioqIQHx/P5Etb+MzMzJASJZVKJSZOnIjExESo1WoYDAbs3LkTJpMJTqcTNpvtP1NH4jgOmZmZmDhxItrb28FxHNLS0uD1erFu3Tps3LgRRASr1Yqenh6cOnUKNpsN8+fPZ8pkMB3DcRwEQUBhYSEUCgVOnTqF0tJSeDwe7NmzBzKZDImJiWxJnT17NoqKioZEJASD2NhYFBUVYdmyZbj22mvZPRMSEiCXy2E0GrFz50709/cz359SqYRGowEwsE3/6U9/ivnz52PKlClBmSCkPsjIyMCcOXOQk5PDdCW9Xg+r1QqPxzOmQhMXNJGICFOmTEFeXh6ysrKgUCiQlZWFvr4+lJWV4fTp0yx/32g0orKyEm1tbWzdD3Z0cT9UOMnLy4PP58Nnn32G1tZWAMDJkyfZcsTzPNLS0nD//fcjMzMT48ePD0kGADa7JCcn45577mF1BrRaLXiex7Fjx1BXVwciQnV1NZqbmwOqpowfPx533XUXNBpNwEmaZwPP88jNzUVaWhomTZqEpKQkmEwmGI1GGI1GuFwudvDzaHBBE0kQBHYC9eLFi5Gbm4v09HR2MndfXx9EUUR7ezscDgc+/PBDVFdXY9GiRZg3b17QehIRISYmBtnZ2ejp6cE///lP1qlmsxkcx7GjSadNm4bCwkL4fD6mr4WyHEj2m4aGBthsNhQUFDCiEhH27NnDdlUdHR34+uuvwXEcoqKiWBmgjo4ORrBgZUs7XbvdDpPJhISEBPT29sJqtaK3txdut/s/l0gqlQqpqaloaGhAR0cHrrzySiQkJODAgQPo7+9HX18fnE4nmpubQUTo7OxEeXk59u/fD51OF1JqtVarRVJSEvbv34/vv/8+oDqH2WxmIz8jIwP/8z//M+So9LNBmiF9Ph9cLhdKS0vx8ssvIz09HQBYSvX+/fuZcdTr9WLv3r1wuVzMgp2YmIinn34a+/btg9vtDikQraWlBfX19WhpaYFKpUJPTw9T3P1tV6PBBU2kqKgo6HQ6VFVVwWQyMT2pvLycuTPMZjO6urqYLaS2thavvPIKs9EEi+joaMjlclRWVsJutwd436X7K5VKVs1DFEUWBBeKHcdqtaKrqwtz586F1WpFeno65HI53G43TCYT26lJOH36NKxWK0RRhFqtRmxsLGQyGWbMmIHW1lZ2OPOZID1fY2MjnnnmGZSXl0MQBJhMJni9XvT19TEX02hxQRPJYrFg27ZtbNYRBAEGgwHHjx8HMLANN5vNbFRKBjtJRwp1hPl8PhZd4P87k8kEn88HuVwOk8mE6667DhqNBocPHwYQ2tJmsViwceNG5ObmYsWKFTh69Ch8Ph+USiV8Pl/ADCMZQH0+H3P/1NfXY+XKlYiNjcUHH3zAnMlng9Q3UiiMVKxLCj+OiYkZVdEzCRc0kVwuF44ePYr9+/ejsrISgiCgs7OTvWyLxYL+/v4hscehQlpyAAxrm1EoFJDJZLDb7XC5XLjllluwdetWHDp0KOQ6RUSE0tJSvP7661i0aBEEQYDP52M7R38XCTAwK0t2MY/Hg+TkZEydOhXPP/88qqqqQm6rNHP7E1Cn0zEL+2jj0S9opy0RweFwYPv27QAGZga32818QiaTCVVVVVi+fDm2bNkCo9EY8NtQ0NfXB5PJhLy8PBbDLEGlUjGLenp6OrZs2YJXXnllyJEOZ2uLBIvFgldeeQWnT59GTEwM27XJZDJmLZcGhkKhgFwuR0pKClOuH330UaY7hQqJpNLA8Pl80Ol07FgvSXao/XdBz0hSoyX7RmNjI1JTUzFr1iw2Qt9++23ExcXhN7/5DVQq1ahmJkmh1uv1yM/PH2Kb4X4oQCoIAvbt24cXXniBjeJQlk//6x0OB7Zs2YJdu3aB4zio1WpmrfffbUrxSSqVCj6fD//4xz+we/du9n2oy7eUvQIMZI0QEQwGA1wuV8i+Q39c0EQajKamJnz77be47777mO/p1KlTWLt2LX70ox9hzpw5o56aXS4XDAYDEhMThxDJbrcz/9uxY8dgtVrDkpIknbwkiiJzUQyOGbdYLLDZbMzvF2wE6EiQdo8ejwd9fX1ML3S5XMz/NhpcFESSplqXy4WNGzciOzsbN954I3uZFRUVqKqqwq9//WvExcWNqjM8Hg+6u7tZUJv/9l+n0zGlXlKIx3oYn79pwufzwWKxoLu7m1Welf7PYDCgp6eHFV/199iPBtJs5/P5YLPZwPM8rFYrHA7HqMJSJFwURPLvtPr6enz00Ue48cYbERcXByKC3W7Hxo0bUVxcjMsvv3xUMkRRRFNTU8CSIaGzsxNWq3XwEZ1ja5QfpKWuq6uLpSRJ97dYLNDpdCx8Zqz2HiBwYAIDM25/fz8LlRkNLgoiSZC2sNu2bYNSqWRpNcAAwfbu3Ytf/vKXzC8VKhobG9mhf/7o6emBx+MZdYz2meA/y+h0uoAZERjQkaTw33CA4zgkJSVBLpezrBG32w2dToekpKRRKdrARUQk/5HY3t6Ozs5OlpLj8/ngdDrx6aefIicnB9OnTw/5pUuWcZlMhtjY2IDfhsPyOxL85Uix4dLzSAPHfzc6WhmSkj1z5kz893//N5qbm4eECU+bNm1UCQXARUQkfzidTrS1tSEnJ4d9J8XxHD58GNddd92olGGDwQCv14u4uLgAHchsNoedQP6QXrLRaByi/4iiCLPZPCars3Q/nueRmZmJL7/8Es899xwzX0jpXD/+8Y8xd+7c/z9E8vl8MBgMyM/PD0ihcblcMBqNmDZtGnNyBksoKWDM6/VCo9EEdKbVag3JQRoqeJ5HdHQ0iwfyf2ZJf/IPYxktRFHEjh078Mknn8BoNDKCiaKIDz/8EDabDY8++ijz/4XUhjE92XmCFEA/adIkdrISx3GQy+XIyMiAVqtlhRaC9YPJZDIUFRUhNzcXmZmZAYFxRANhuBI5x6or+Z8EJQgCcnJyMGXKFMTHxw+5L8/z0Gq1mD59OtLS0pgxNlRS+Vu0vV4vs81Jn+PHj+Ppp5+G0+lEampqyG286IjEcQPHbEn591IulqQk1tXV4aOPPmK2n2AwceJEfPXVV3jttdfw8ccfo7y8fIib4oorrsCRI0fwu9/9DtHR0WM+HYnnecybNw8HDhxAWVkZWltbsXfv3mGv3bFjB0RRRE1NDXbs2IGioqJRyx4JXq8Xn332GX70ox+htrY2dENniFbRc6cohICEhASsXLkS/f39ePfdd1mYhUwmQ3x8PGQyGbq7u4O+X3R0NIqLi2E0GlnQvX+/REdH4/LLL8eKFSugUCiwZs0atLS0jC3FmeeRlZXFzj85duwYLBbLsC9POsZ96tSpSE5Oxr59+9Db2zvqWkahgIiCGo0XJZGkSEWPx8MyVf2ne2kaD+V+EoYbidK9lUolBEFgPqrREsl/2fA3fI70LkZaZsZqFA0G/9FE8k8DkjrTv7NHs00fnE820v/zPB+QVj0a+JPCn0jB/kb6d4RIEVw0CJZIF52yHcGFiQiRIggLIkSKICyIECmCsCBCpAjCggiRIggLIkSKICyIECmCsCBCpAjCggiRIggLIkSKICyIECmCsCBCpAjCggiRIggLIkSKICyIECmCsCCkwLYIIhgJkRkpgrAgQqQIwoIIkSIICyJEiiAsiBApgrAgQqQIwoIIkSIICyJEiiAsiBApgrAgQqQIwoL/BejeSNX9bnBcAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1800x1800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# CV2读入图片后为BGR模式，而plt画图则是RGB模式，这就导致图片颜色发生很大变化\r\n",
    "# 故采用cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)将读入的BGR图片转换为RGB图片\r\n",
    "img_BGR = cv2.imread(\"/home/aistudio/data/imgs/100001.png\")[:,:,:3]\r\n",
    "img_RGB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)\r\n",
    "# p = Image.open(\"work/imgs/kanasi_female_vcg_raw_page4_30.jpg\")\r\n",
    "print(img_RGB.shape)\r\n",
    "image = np.array(img_RGB)\r\n",
    "plt.figure(figsize=(25,25))\r\n",
    "plt.subplot(10, 10,  1)\r\n",
    "plt.imshow(image, vmin=-1, vmax=1)\r\n",
    "plt.axis('off')\r\n",
    "plt.xticks([])\r\n",
    "plt.yticks([])\r\n",
    "plt.subplots_adjust(wspace=0.1, hspace=0.1)\r\n",
    "plt.show()\r\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2 测试Paddle.io.DataLoader并输出图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var img : paddle.VarType.LOD_TENSOR.shape(-1, 3, 128, 128).astype(VarType.FP32)\n"
     ]
    }
   ],
   "source": [
    "train_dataset = DataGenerater()\r\n",
    "imgs = paddle.static.data(name='img', shape=[None,3,img_dim,img_dim], dtype='float32')\r\n",
    "print(imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x1800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "train_loader = paddle.io.DataLoader(\n",
    "    train_dataset, \n",
    "    places=paddle.CPUPlace(), \n",
    "    feed_list = [imgs],\n",
    "    batch_size=config['batch_size'], \n",
    "    shuffle=True,\n",
    "    num_workers=2,\n",
    "    use_buffer_reader=True,\n",
    "    use_shared_memory=False,\n",
    "    # drop_last (bool) - 是否丢弃因数据集样本数不能被 batch_size 整除而产生的最后一个不完整的mini-batch，为 batch_sampler 的替代参数\n",
    "    drop_last=True,\n",
    "    )\n",
    "\n",
    "for batch_id, data in enumerate(train_loader()):\n",
    "    plt.figure(figsize=(25,25))\n",
    "    try:\n",
    "        for i in range(4):\n",
    "            # 1,3,512,512 -> 512,512,3\n",
    "            image = np.array(data[0][i])[0].transpose((2,1,0))\n",
    "            image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\n",
    "            plt.subplot(10, 10, i + 1)\n",
    "            plt.imshow(image, vmin=-1, vmax=1)\n",
    "            plt.axis('off')\n",
    "            plt.xticks([])\n",
    "            plt.yticks([])\n",
    "            plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
    "        plt.suptitle('\\n Training Images',fontsize=30)\n",
    "        plt.show()\n",
    "        break\n",
    "    except IOError:\n",
    "        print(IOError)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.3 权重初始化\n",
    "参考在 DCGAN 论文中，作者指定所有模型权重应从均值为0、标准差为0.02的正态分布中随机初始化。  \n",
    "在paddle.nn中，调用fluid.nn.initializer.Normal实现initialize设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "conv_initializer=paddle.nn.initializer.Normal(mean=0.0, std=0.02)\r\n",
    "bn_initializer=paddle.nn.initializer.Normal(mean=1.0, std=0.02)\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.4 判别器\n",
    "如上文所述，生成器$D$是一个二进制分类网络，它以图像作为输入，输出图像是真实的（相对应$G$生成的假样本）的概率。输入$Shape$为[3,128,128]的RGB图像，通过一系列的$Conv2d$，$BatchNorm2d$和$LeakyReLU$层对其进行处理，然后通过全连接层输出的神经元个数为2，对应两个标签的预测概率。\n",
    "\n",
    "* 将BatchNorm批归一化中momentum参数设置为0.5\n",
    "* 将判别器(D)激活函数leaky_relu的alpha参数设置为0.2\n",
    "\n",
    "> 输入:  为大小128*128的RGB三通道图片  \n",
    "> 输出:  经过一层全连接层最后为shape为[batch_size,2]的Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle\n",
    "import paddle.nn as nn\n",
    "import paddle.nn.functional as F\n",
    "img_dim=config['img_dim']\n",
    "class Discriminator(paddle.nn.Layer):\n",
    "    def __init__(self,img_dim=img_dim):\n",
    "        super(Discriminator, self).__init__()\n",
    "        # class paddle.nn.Conv2D(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', weight_attr=None, bias_attr=None, data_format='NCHW')\n",
    "        # 在判别器中第一层卷积和第二层卷积之间不需要用batchNorm\n",
    "        # 3*512*512\n",
    "        self.conv_1 = nn.Conv2D(\n",
    "            3,64,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_1_\",initializer=conv_initializer)\n",
    "            )\n",
    "        # 64*256*256\n",
    "        self.conv_2 = nn.Conv2D(\n",
    "            64,img_dim,4,2,1,\n",
    "            #64,128,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_2_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_2 = nn.BatchNorm2D(\n",
    "            img_dim,\n",
    "            #128，\n",
    "            weight_attr=paddle.ParamAttr(name=\"d_2_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 128*128*128\n",
    "        self.conv_3 = nn.Conv2D(\n",
    "            #128,256,4,2,1,\n",
    "            img_dim,256,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_3_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_3 = nn.BatchNorm2D(\n",
    "            256,\n",
    "            weight_attr=paddle.ParamAttr(name=\"d_3_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 256*64*64\n",
    "        self.conv_4 = nn.Conv2D(\n",
    "            256,512,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_4_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_4 = nn.BatchNorm2D(\n",
    "            512,\n",
    "            weight_attr=paddle.ParamAttr(name=\"d_4_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        self.conv_5 = nn.Conv2D(\n",
    "            512,1024,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_5_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_5 = nn.BatchNorm2D(\n",
    "            1024,\n",
    "            weight_attr=paddle.ParamAttr(name=\"d_5_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        self.conv_6 = nn.Conv2D(\n",
    "            1024,1,4,1,0,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"d_conv_weight_6_\",initializer=conv_initializer)\n",
    "        )\n",
    "        # 1*1*1\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.conv_1(x)\n",
    "        x = F.leaky_relu(x,negative_slope=0.2)\n",
    "        x = self.conv_2(x)\n",
    "        x = self.bn_2(x)\n",
    "        x = F.leaky_relu(x,negative_slope=0.2)\n",
    "        x = self.conv_3(x)\n",
    "        x = self.bn_3(x)\n",
    "        x = F.leaky_relu(x,negative_slope=0.2)\n",
    "        x = self.conv_4(x)\n",
    "        x = self.bn_4(x)\n",
    "        x = F.leaky_relu(x,negative_slope=0.2)\n",
    "        x = self.conv_5(x)\n",
    "        x = self.bn_5(x)\n",
    "        x = F.leaky_relu(x,negative_slope=0.2)\n",
    "        x = self.conv_6(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 采用LSGAN\n",
    "去掉判别器网络的sigmoid函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.5 生成器\n",
    "生成器$G$旨在映射潜在空间矢量$z$到数据空间。由于我们的数据是图像，因此转换$z$到数据空间意味着最终创建具有与训练图像相同大小[3,128,128]的RGB图像。在网络设计中，这是通过一系列二维卷积转置层来完成的，每个层都与$BatchNorm$层和$ReLu$激活函数。生成器的输出通过$tanh$函数输出，以使其返回到输入数据范围[−1,1]。值得注意的是，在卷积转置层之后存在$BatchNorm$函数，因为这是DCGAN论文的关键改进。这些层有助于训练过程中的梯度更好地流动。  \n",
    "\n",
    "* 将$BatchNorm$批归一化中$momentum$参数设置为0.5\n",
    "\n",
    "> 输入:Tensor的Shape为[batch_size,100]其中每个数值大小为0~1之间的float32随机数  \n",
    "> 输出:3x128*128RGB三通道图片\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle\n",
    "import paddle.nn as nn\n",
    "import paddle.nn.functional as F\n",
    "try:\n",
    "    G_DIMENSION=config['G_DIMENSION']\n",
    "except:\n",
    "    G_DIMENSION=100\n",
    "class Generator(paddle.nn.Layer):\n",
    "    def __init__(self,G_DIMENSION=G_DIMENSION):\n",
    "        super(Generator, self).__init__()\n",
    "        self.conv_1 = nn.Conv2DTranspose(\n",
    "            #100,1024,4,1,0,\n",
    "            G_DIMENSION,1024,4,1,0,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_1_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_1 = nn.BatchNorm2D(\n",
    "            1024,\n",
    "            weight_attr=paddle.ParamAttr(name=\"g_1_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 512 * 32 * 32\n",
    "        self.conv_2 = nn.Conv2DTranspose(\n",
    "            1024,512,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_2_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_2 = nn.BatchNorm2D(\n",
    "            512,\n",
    "            weight_attr=paddle.ParamAttr(name=\"g_2_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 256 * 64 * 64\n",
    "        self.conv_3 = nn.Conv2DTranspose(\n",
    "            512,256,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_3_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_3 = nn.BatchNorm2D(\n",
    "            256,\n",
    "            weight_attr=paddle.ParamAttr(name=\"g_3_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 128 * 128 * 128\n",
    "        self.conv_4 = nn.Conv2DTranspose(\n",
    "            256,128,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_4_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_4 = nn.BatchNorm2D(\n",
    "            128,\n",
    "            weight_attr=paddle.ParamAttr(name=\"g_4_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        self.conv_5 = nn.Conv2DTranspose(\n",
    "            128,64,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_5_\",initializer=conv_initializer)\n",
    "            )\n",
    "        self.bn_5 = nn.BatchNorm2D(\n",
    "            64,\n",
    "            weight_attr=paddle.ParamAttr(name=\"g_5_bn_weight_\",initializer=bn_initializer),momentum=0.8\n",
    "            )\n",
    "        # 64 * 256 * 256\n",
    "        self.conv_6 = nn.Conv2DTranspose(\n",
    "            64,3,4,2,1,\n",
    "            bias_attr=False,weight_attr=paddle.ParamAttr(name=\"g_dconv_weight_6_\",initializer=conv_initializer)\n",
    "            )\n",
    "        # 3 * 64 * 64\n",
    "        self.tanh = paddle.nn.Tanh()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.conv_1(x)\n",
    "        x = self.bn_1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.conv_2(x)\n",
    "        x = self.bn_2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.conv_3(x)\n",
    "        x = self.bn_3(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.conv_4(x)\n",
    "        x = self.bn_4(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.conv_5(x)\n",
    "        x = self.bn_5(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.conv_6(x)\n",
    "        print('conv_6',x.shape)\n",
    "        x = self.tanh(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.6 损失函数\n",
    "选用BCELoss,公式如下:\n",
    "\n",
    "  $Out = -1 * (label * log(input) + (1 - label) * log(1 - input))$\n",
    " \n",
    " LSGAN将BCELoss改成MSELoss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "###损失函数\n",
    "# loss = paddle.nn.BCELoss()\n",
    "# 改为\n",
    "loss = paddle.nn.MSELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 4 模型训练\n",
    " \n",
    "训练过程中的每一次迭代，生成器和判别器分别设置自己的迭代次数。为了避免判别器快速收敛到0，本教程默认每迭代一次，训练 1次判别器，4次生成器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import IPython.display as display\n",
    "import warnings\n",
    "from visualdl import LogWriter\n",
    "import paddle.optimizer as optim\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "#vdl_train=LogWriter('vdl_dygraph/train')\n",
    "\n",
    "# img_dim = 512\n",
    "img_dim = config['img_dim']\n",
    "lr =config['lr']\n",
    "epoch = config['epoch']\n",
    "output = config['output']\n",
    "batch_size = config['batch_size']\n",
    "G_DIMENSION = config['G_DIMENSION']\n",
    "beta1 = config['beta1']\n",
    "beta2 = config['beta2']\n",
    "output_path = config['output_path']\n",
    "#device = paddle.set_device('gpu')\n",
    "paddle.disable_static()\n",
    "\n",
    "real_label = 1.\n",
    "fake_label = 0.\n",
    "\n",
    "netD = Discriminator()\n",
    "netG = Generator()\n",
    "optimizerD = optim.Adam(parameters=netD.parameters(), learning_rate=lr, beta1=beta1, beta2=beta2)\n",
    "optimizerG = optim.Adam(parameters=netG.parameters(), learning_rate=lr, beta1=beta1, beta2=beta2)\n",
    "##\n",
    "state_dict = paddle.load(\"/home/aistudio/work/generator072502.params\")\n",
    "netG.set_state_dict(state_dict)\n",
    "###训练过程\n",
    "losses = [[], []]\n",
    "#plt.ion()\n",
    "now = 0\n",
    "for pass_id in range(epoch):\n",
    "    # enumerate()函数将一个可遍历的数据对象组合成一个序列列表\n",
    "    for batch_id, data in enumerate(train_loader()):\n",
    "        #训练判别器 \n",
    "        optimizerD.clear_grad()\n",
    "        real_cpu = data[0]\n",
    "        label = paddle.full((batch_size,1,1,1),real_label,dtype='float32')\n",
    "        output = netD(real_cpu)\n",
    "        errD_real = loss(output,label)\n",
    "        errD_real.backward()\n",
    "        optimizerD.step()\n",
    "        optimizerD.clear_grad()\n",
    "\n",
    "        noise = paddle.randn([batch_size,G_DIMENSION,1,1],'float32')\n",
    "        fake = netG(noise)\n",
    "        label = paddle.full((batch_size,1,1,1),fake_label,dtype='float32')\n",
    "        output = netD(fake.detach())\n",
    "        errD_fake = loss(output,label)\n",
    "        errD_fake.backward()\n",
    "        optimizerD.step()\n",
    "        optimizerD.clear_grad()\n",
    "\n",
    "        errD = errD_real + errD_fake\n",
    "        \n",
    "        losses[0].append(errD.numpy()[0])\n",
    "        ###训练生成器\n",
    "        optimizerG.clear_grad()\n",
    "        noise = paddle.randn([batch_size,G_DIMENSION,1,1],'float32')\n",
    "        fake = netG(noise)\n",
    "        label = paddle.full((batch_size,1,1,1),real_label,dtype=np.float32,)\n",
    "        output = netD(fake)\n",
    "        errG = loss(output,label)\n",
    "        errG.backward()\n",
    "        optimizerG.step()\n",
    "        optimizerG.clear_grad()\n",
    "        ###训练生成器\n",
    "        optimizerG.clear_grad()\n",
    "        noise = paddle.randn([batch_size,G_DIMENSION,1,1],'float32')\n",
    "        fake = netG(noise)\n",
    "        label = paddle.full((batch_size,1,1,1),real_label,dtype=np.float32,)\n",
    "        output = netD(fake)\n",
    "        errG = loss(output,label)\n",
    "        errG.backward()\n",
    "        optimizerG.step()\n",
    "        optimizerG.clear_grad()\n",
    "        ###训练生成器\n",
    "        optimizerG.clear_grad()\n",
    "        noise = paddle.randn([batch_size,G_DIMENSION,1,1],'float32')\n",
    "        fake = netG(noise)\n",
    "        label = paddle.full((batch_size,1,1,1),real_label,dtype=np.float32,)\n",
    "        output = netD(fake)\n",
    "        errG = loss(output,label)\n",
    "        errG.backward()\n",
    "        optimizerG.step()\n",
    "        optimizerG.clear_grad()\n",
    "        \n",
    "        losses[1].append(errG.numpy()[0])\n",
    "        if  batch_id % 400 == 0 or pass_id%400==0:\n",
    "            \n",
    "            paddle.save(netG.state_dict(), \"/home/aistudio/checkpoint/generator\"+str(pass_id)+\".params\")\n",
    "        if batch_id % 400 == 0:\n",
    "            \n",
    "            if not os.path.exists(output_path):\n",
    "                os.makedirs(output_path)\n",
    "            # 每轮的生成结果\n",
    "            generated_image = netG(noise).numpy()\n",
    "            ##\n",
    "            #vdl_train.add_scalar(tag=\"train/D-loss\", step=batch_id, value=errD.numpy()[0])\n",
    "            #vdl_train.add_scalar(tag=\"train/G-Loss\", step=batch_id, value=errG.numpy()[0])\n",
    "            \n",
    "            #vdl_train.add_image(tag=\"generated_image\", img=generated_image,step=batch_id)\n",
    "            ##\n",
    "            imgs = []\n",
    "            plt.figure(figsize=(25,25))\n",
    "            try:\n",
    "                for i in range(4):\n",
    "                    image = generated_image[i].transpose()\n",
    "                    image = np.where(image > 0, image, 0)\n",
    "                    \n",
    "                    image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\n",
    "                    plt.subplot(10, 10, i + 1)\n",
    "                    plt.imshow(image, vmin=-1, vmax=1)\n",
    "                    plt.axis('off')\n",
    "                    plt.xticks([])\n",
    "                    plt.yticks([])\n",
    "                    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(pass_id, batch_id, errD.numpy()[0], errG.numpy()[0])\n",
    "                plt.suptitle(msg,fontsize=20)\n",
    "                plt.draw()\n",
    "                plt.savefig('{}/{:04d}_{:04d}.png'.format(output_path, pass_id, batch_id),bbox_inches='tight')\n",
    "                plt.pause(0.01)\n",
    "                display.clear_output(wait=True)\n",
    "            except IOError:\n",
    "\n",
    "                print(IOError)\n",
    "    print(\"epoch:{}/{}\".format(pass_id,epoch))\n",
    "\n",
    "paddle.save(netG.state_dict(), \"/home/aistudio/work/generator.params\")\n",
    "\n",
    "plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 6))\n",
    "x = np.arange(len(losses[0]))\n",
    "plt.title('Generator and Discriminator Loss During Training')\n",
    "plt.xlabel('Number of Batch')\n",
    "plt.plot(x,np.array(losses[0]),label='D Loss')\n",
    "plt.plot(x,np.array(losses[1]),label='G Loss')\n",
    "plt.legend()\n",
    "plt.savefig('/home/aistudio/work/Generator and Discriminator Loss During Training.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\r\n",
    "paddle.save(netG.state_dict(), \"/home/aistudio/work/generator072502.params\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 6 模型预测\n",
    "### 输入随机数让生成器$G$生成随机风景图片\n",
    "生成的RGB三通道128*128的图片路径位于“worl/Generate/”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle\n",
    "import paddle.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display as display\n",
    "##\n",
    "conv_initializer=paddle.nn.initializer.Normal(mean=0.0, std=0.02)\n",
    "bn_initializer=paddle.nn.initializer.Normal(mean=1.0, std=0.02)\n",
    "##\n",
    "device = paddle.set_device('gpu')\n",
    "paddle.disable_static(device)\n",
    "try:\n",
    "    \n",
    "    netG = Generator()\n",
    "    state_dict = paddle.load(\"/home/aistudio/work/generator0725.params\")\n",
    "    netG.set_state_dict(state_dict)\n",
    "    noise = paddle.randn([100,100,1,1],'float32')\n",
    "    # generated_image = generate(noise).numpy()\n",
    "    generated_image = netG(noise).numpy()\n",
    "    imgs = []\n",
    "    plt.figure(figsize=(25,25))\n",
    "    for i in range(8):\n",
    "        image = generated_image[i].transpose()\n",
    "        image = np.where(image > 0, image, 0)\n",
    "        plt.subplot(10, 10, i + 1)\n",
    "        plt.imshow(image, vmin=-1, vmax=1)\n",
    "        plt.axis('off')\n",
    "        plt.xticks([])\n",
    "        plt.yticks([])\n",
    "        plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
    "    plt.draw()\n",
    "    plt.savefig('generate072502.png',bbox_inches='tight')\n",
    "    plt.pause(0.01)\n",
    "    display.clear_output(wait=True)\n",
    "except IOError:\n",
    "    print(IOError)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# !mv work/Generator\\ and\\ Discriminator\\ Loss\\ During\\ Training.png Generator\\ and\\ Discriminator\\ Loss\\ During\\ Training.png"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 2.0.0b0 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
